#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
账号线程模块

这个模块提供了账号自动化任务的线程管理。
"""

import time
import os
from PyQt6.QtCore import QThread, pyqtSignal
from xiaohongshu_bot import XiaohongshuBot
from logger import get_logger

# 获取日志记录器
logger = get_logger(__name__)

class AccountThread(QThread):
    """账号线程类，用于执行账号自动化任务"""

    # 定义信号
    status_changed = pyqtSignal(str)  # 状态信息
    task_completed = pyqtSignal(bool)  # 任务完成状态
    error_occurred = pyqtSignal(str)  # 错误信息
    login_success = pyqtSignal(str, dict)  # 账号ID, 用户信息
    log_updated = pyqtSignal(str, str)  # 账号ID, 日志信息
    status_updated = pyqtSignal(str, str)  # 账号ID, 状态信息

    def __init__(self, thread_id, account_data=None, port=None, config_manager=None, parent=None):
        """初始化账号线程

        Args:
            thread_id: 线程ID（可以是端口号或临时ID）
            account_data: 账号数据，包含关键词、回复等信息
            port: 浏览器端口
            config_manager: 配置管理器实例
            parent: 父对象
        """
        super().__init__(parent)
        self.thread_id = thread_id
        self.account_data = account_data if account_data else {}
        self.config_manager = config_manager

        # 确定端口号的逻辑：
        # 1. 优先尝试从 account_data['port'] 获取，前提是它是一个整数。
        # 2. 如果 account_data['port'] 不是整数或不存在，则尝试使用 __init__ 的 port 参数，前提是它是一个整数。
        # 3. 如果两者都无效，则 self.port 设置为 None，后续 _init_bot 会尝试自动分配。
        potential_port_from_data = self.account_data.get('port')
        if isinstance(potential_port_from_data, int):
            self.port = potential_port_from_data
            logger.debug(f"AccountThread {self.thread_id}: Using port {self.port} from account_data.")
        elif port is not None and isinstance(port, int): # port is the parameter to __init__
            self.port = port
            logger.warning(f"AccountThread {self.thread_id}: Using port {self.port} from __init__ parameter. account_data['port'] was '{potential_port_from_data}' (type: {type(potential_port_from_data).__name__}).")
        else:
            self.port = None
            logger.warning(f"AccountThread {self.thread_id}: No valid integer port found in account_data (value: '{potential_port_from_data}', type: {type(potential_port_from_data).__name__}) or __init__ parameter (value: '{port}', type: {type(port).__name__}). Will attempt to find/assign port later.")
        self.bot = None
        self.is_running = True

    def run(self):
        """运行线程"""
        try:

            print(f"账号 {self.account_data} 开始运行...")
            # 初始化机器人
            if not self._init_bot():
                return

            # 处理登录 - 这里会发送login_success信号
            if not self._handle_login():
                logger.error(f"账号 {self.port} 登录失败")
                return


            print(f"账号 {self.port} 准备开始任务...")
            # 如果有关键词和回复，则执行任务
            keyword = self.account_data.get('keywords', "")
            print(f"关键词 {keyword}")
            replies = self.account_data.get('replies', [])
            if keyword and replies:
                print(f"关键词 {keyword} 开始执行任务...")
                if not self._execute_task():
                    return

            print(f"账号 {self.port} 任务完成")
            # 清理资源
            self._cleanup()

            # 发送完成信号
            self.task_completed.emit(True)

        except Exception as e:
            self._handle_error(str(e))
        finally:
            self._cleanup()

    def _init_bot(self):
        """初始化机器人

        Returns:
            bool: 是否初始化成功
        """
        try:
            # 确保端口存在
            if not self.port:
                from account_manager import AccountManager
                account_manager = AccountManager()
                self.port = account_manager.find_available_port()
                logger.info(f"分配新端口: {self.port}")

            # 使用端口号作为用户数据目录名
            user_data_dir = os.path.join("temp", "user_data", f"port_{self.port}")

            self.bot = XiaohongshuBot(
                user_data_dir=user_data_dir,
                port=self.port
            )
            # 绑定日志信号，将日志按 port 转发到 log_updated
            self.bot.log_signal.connect(self._handle_bot_log)
            self._update_status("机器人初始化成功")
            return True
        except Exception as e:
            self._handle_error(f"初始化机器人失败: {str(e)}")
            return False

    def _handle_bot_log(self, message, port):
        """处理 bot 日志信号，按 port 转发到 log_updated"""
        self.log_updated.emit(str(port), message)

    def _handle_login(self):
        """处理登录流程

        Returns:
            bool: 是否登录成功
        """
        try:
            self._update_status("检查登录状态...")
            is_logged, user_info = self.bot.login()

            if is_logged and user_info and isinstance(user_info, dict):
                self._update_status("登录成功")
                if 'port' not in user_info or user_info['port'] is None:
                    user_info['port'] = self.port
                user_info['is_logged'] = True
                if 'keywords' not in user_info:
                    user_info['keywords'] = ""
                if 'replies' not in user_info:
                    user_info['replies'] = ""
                self.login_success.emit(self.thread_id, user_info)
                logger.info(f"已发送登录成功信号，用户名: {user_info.get('nickname', '未知')}, 端口: {user_info.get('port')}")
                return True
            else:
                logger.warning(f"登录失败或用户信息无效: {user_info}")
                self._handle_error("登录失败或用户信息无效")
                return False
        except Exception as e:
            self._handle_error(f"登录过程出错: {str(e)}")
            return False

    def _execute_task(self):
        """执行自动化任务

        Returns:
            bool: 是否执行成功
        """
        print(f"账号 {self.port} 开始执行任务...")
        try:
            keyword = self.account_data.get('keywords', "")
            replies = self.account_data.get('replies', [])
            max_posts = self.account_data.get('max_posts', 5)

            if not keyword or not replies:
                logger.info(f"账号 {self.port} 没有设置关键词或回复内容，跳过执行任务。")
                self._update_status("没有设置关键词或回复内容，跳过任务")
                return True

            self._update_status(f"开始搜索关键词: {keyword}")
            print(f"max_posts: {max_posts}")

            if not self.bot.search_and_comment(keyword, replies, max_posts=max_posts):
                self._handle_error("搜索评论任务失败")
                return False

            self._update_status("任务执行完成")
            return True
        except Exception as e:
            print(f"执行任务时出错: {str(e)}")
            self._handle_error(f"执行任务时出错: {str(e)}")
            return False

    def _handle_error(self, error_msg):
        """处理错误

        Args:
            error_msg: 错误信息
        """
        logger.error(f"[端口:{self.port}] [线程:{self.thread_id}] {error_msg}")
        self.error_occurred.emit(error_msg)
        self.task_completed.emit(False)

    def _cleanup(self):
        """清理资源"""
        try:
            if self.bot:
                self.bot.quit()
                self.bot = None
        except Exception as e:
            logger.error(f"清理资源时出错: {str(e)}")

    def _update_status(self, status):
        """更新状态信息

        Args:
            status: 状态信息
        """
        logger.info(f"[端口:{self.port}] {status}", extra={'thread_id': self.thread_id, 'account_id': self.port})
        self.status_changed.emit(status)

    def stop(self):
        """停止线程"""
        self.is_running = False
        self._cleanup()
        self.wait()
